package Sort;

/**
 * @author shy_black
 * @date 2019/4/29 16:07
 * @Description:
 * 堆排序原理（过程）：
 * 1.先将数组转化为堆的形式
 * 2.循环：每次将堆顶元素与数组末尾元素交换，将数组大小减一
 * 然后进行shifDown操作（还原剩余数组的堆形式，使得堆顶元素还是最大）
 * 细节：
 *  shifDown：寻找当前节点的较大子节点，
 *  找到后交换当前元素与子节点的位置，
 *  更新当前元素下标为子节点下标
 *  如果当前元素已经大于较大子节点，则表示堆的形式已经完成，堆顶已为最大元素
 */
public class 堆排序 {
    public static void heapSort(Integer[] arr) {
        int n = arr.length;
        //heapify
        for(int i = (n-1)/2 ;i>=0;i--) {
            siftDown(arr,i,n);
        }
        //排序过程
        for(int i = n-1;i > 0;i--) {
            //每次排序先将堆顶元素放在元素末尾
            swap(arr,0,i);
            //从顶点开始对堆进行排序，找出最大的元素
            siftDown(arr,0,i);
        }
        for(Integer i : arr) {
            System.out.print(i+"_");
        }
    }
    private static void siftDown(Integer[] arr,int i,int length) {
        //先对定点元素存储
        //i始终为当前节点

        Integer temp = arr[i];
        //找到i节点的子节点，

        //i是最后一个叶子节点的父节点，
        //k = 2*i + 1 --->最后一个叶子节点
        //k = 2*k + 1 --->如果程序不break，会运行则将k赋值为
        for(int k = 2*i + 1;k <length;k = 2*k +1) {

            //如果i节点的子节点下标不越界，找arr[k]和arr[k+1]中较大的一个
            if(k+1 < length && arr[k] < arr[k+1])
                k++;


            //arr[k]是待比较的较大子节点，如果较大子节点比temp大，
            //那么交换元素位置，并且改变i的大小为子节点下标k


            if(arr[k] > temp) {
                swap(arr,i,k);
                i = k;
            }else {
                break;
            }
        }
    }
    private static void swap(Integer[] arr,int i,int j) {
        Integer t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    public static void main(String[] args) {
        Integer[] arr = new Integer[]{4, 3, 6, 2, 7, 3, 6, 3, 89, 5, 4, 5, 2, 8, 0};
        heapSort(arr);
    }
}
